home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 326-350 / disk_349 / med / source / med200src.zoo / med-files.c < prev    next >
C/C++ Source or Header  |  1990-04-08  |  17KB  |  514 lines
  1. /* MED-files.c: V2.00 file loading/saving routines by T. Kinnunen 1990 */
  2.  
  3. #include <workbench/icon.h>
  4. #include <workbench/workbench.h>
  5. #include <proto/icon.h>
  6. #include "med.h"
  7. static BPTR fh;
  8. extern struct Gadget far gadget1[],far gadget2[];
  9. extern struct Kappale far tamakappale;
  10. extern UWORD lohkoja,soittimennum,nykyinenosio;
  11. BOOL diskerr(),AskName();
  12. extern struct Lohko *lohko[];
  13. extern struct Soitin *soitin[];
  14. extern struct Window *window;
  15. extern struct Screen *screen;
  16. extern char kappaleennimi[];
  17. BOOL WriteIcon(),Continue();
  18. #define M0F_LINEMSK0F    0x1
  19. #define M0F_LINEMSK1F    0x2
  20. #define M0F_FXMSK0F    0x4
  21. #define M0F_FXMSK1F    0x8
  22. #define M0F_LINEMSK00    0x10
  23. #define M0F_LINEMSK10    0x20
  24. #define M0F_FXMSK00    0x40
  25. #define M0F_FXMSK10    0x80
  26.  
  27. static BOOL FWrite(char *ptr,long len)
  28. {
  29.     return((BOOL)(Write(fh,ptr,len) != len));
  30. }
  31.  
  32. static BOOL FRead(BPTR fh,char *ptr,long len)
  33. {
  34.     return((BOOL)(Read(fh,ptr,len) != len));
  35. }
  36.  
  37. static void PutNibble(UBYTE *mem,UWORD *nbnum,UBYTE nibble)
  38. {
  39.     UBYTE *mloc = mem + (*nbnum / 2);
  40.     if(*nbnum & 0x1) *mloc |= (nibble & 0x0f);
  41.     else *mloc |= (nibble << 4);
  42.     (*nbnum)++;
  43. }
  44.  
  45. static UBYTE GetNibble(UBYTE *mem,UWORD *nbnum)
  46. {
  47.     UBYTE *mloc = mem + (*nbnum / 2),res;
  48.     if(*nbnum & 0x1) res = *mloc & 0x0f;
  49.     else res = *mloc >> 4;
  50.     (*nbnum)++;
  51.     return(res);
  52. }
  53.  
  54. static void PutNibbles(UBYTE *mem,UWORD *nbnum,UWORD nbls,UBYTE nbs)
  55. {
  56.     switch(nbs) {
  57.         case 0x4:    PutNibble(mem,nbnum,(UBYTE)(nbls >> 12));
  58.         case 0x3:    PutNibble(mem,nbnum,(UBYTE)(nbls >> 8));
  59.         case 0x2:    PutNibble(mem,nbnum,(UBYTE)(nbls >> 4));
  60.         case 0x1:    PutNibble(mem,nbnum,(UBYTE)nbls);
  61.     }
  62. }
  63.  
  64. static UWORD GetNibbles(UBYTE *mem,UWORD *nbnum,UBYTE nbs)
  65. {
  66.     UWORD res = 0;
  67.     while(nbs--) { res <<= 4; res |= GetNibble(mem,nbnum); }
  68.     return(res);
  69. }
  70.  
  71. static BOOL SaveBlock(UWORD num)
  72. {
  73.     UBYTE *tmpfr,trkn = lohko[num]->numtracks,m0fbits = 0;
  74.     UBYTE *conv = AllocMem(ONETRKSIZE * (trkn + 2),MEMF_PUBLIC|MEMF_CLEAR),
  75.         *from,lcnt,bcnt;
  76.     ULONG linemsk0 = 0,linemsk1 = 0,*lmptr = &linemsk0;
  77.     ULONG l2msk0 = 0,l2msk1 = 0,*l2ptr = &l2msk0;
  78.     UWORD lmsk0,lmsk1,ton = 0,data;
  79.     if(!conv) return(TRUE);
  80.     from = lohko[num]->music;
  81.     for(lcnt = 0; lcnt < 64; lcnt++) {
  82.         lmsk0 = lmsk1 = 0;
  83.         if(lcnt == 32) { lmptr = &linemsk1; l2ptr = &l2msk1; }
  84.         *lmptr <<= 1; *l2ptr <<= 1;
  85.         tmpfr = from;
  86.         for(bcnt = 0; bcnt < trkn; bcnt++) {
  87.             lmsk0 <<= 1; lmsk1 <<= 1;
  88.             if(*tmpfr || (*(tmpfr+1) & 0xf0)) lmsk0 |= 1;
  89.             if((*(tmpfr+1) & 0x0f) || *(tmpfr+2)) lmsk1 |= 1;
  90.             tmpfr += 3;
  91.         }
  92.         if(lmsk0) {
  93.             *lmptr |= 1;
  94.             PutNibbles(conv,&ton,lmsk0,(UBYTE)(trkn / 4));
  95.             tmpfr = from;
  96.             for(bcnt = 0; bcnt < trkn; bcnt++) {
  97.                 if(*tmpfr || (*(tmpfr+1) & 0xf0)) {
  98.                     data = (UWORD)((*tmpfr << 4) |
  99.                         ((*(tmpfr+1) & 0xf0) >> 4));
  100.                     PutNibbles(conv,&ton,data,3);
  101.                 }
  102.                 tmpfr += 3;
  103.             }
  104.         }
  105.         if(lmsk1) {
  106.             *l2ptr |= 1;
  107.             PutNibbles(conv,&ton,lmsk1,(UBYTE)(trkn / 4));
  108.             tmpfr = from + 1;
  109.             for(bcnt = 0; bcnt < trkn; bcnt++) {
  110.                 if((*tmpfr & 0x0f) || *(tmpfr+1)) {
  111.                     data = (UWORD)(((*tmpfr & 0x0f)
  112.                         << 8) | (*(tmpfr+1)));
  113.                     PutNibbles(conv,&ton,data,3);
  114.                 }
  115.                 tmpfr += 3;
  116.             }
  117.         }
  118.         from += 3 * trkn;
  119.     }
  120.     if(FWrite((char *)(&lohko[num]->numtracks),1)) goto sberr;
  121.     data = (ton + 1) / 2; /* length of the packed block */
  122.     if(linemsk0 == 0xffffffff) m0fbits |= M0F_LINEMSK0F;
  123.     else if(linemsk0 == 0x00000000) m0fbits |= M0F_LINEMSK00;
  124.     if(linemsk1 == 0xffffffff) m0fbits |= M0F_LINEMSK1F;
  125.     else if(linemsk1 == 0x00000000) m0fbits |= M0F_LINEMSK10;
  126.     if(l2msk0 == 0xffffffff) m0fbits |= M0F_FXMSK0F;
  127.     else if(l2msk0 == 0x00000000) m0fbits |= M0F_FXMSK00;
  128.     if(l2msk1 == 0xffffffff) m0fbits |= M0F_FXMSK1F;
  129.     else if(l2msk1 == 0x00000000) m0fbits |= M0F_FXMSK10;
  130.     if(FWrite((char *)(&m0fbits),1)) goto sberr;
  131.     if(FWrite((char *)(&data),2)) goto sberr;
  132.     if(!(m0fbits & (M0F_LINEMSK00 | M0F_LINEMSK0F)))
  133.         if(FWrite((char *)(&linemsk0),4)) goto sberr;
  134.     if(!(m0fbits & (M0F_LINEMSK10 | M0F_LINEMSK1F)))
  135.         if(FWrite((char *)(&linemsk1),4)) goto sberr;
  136.     if(!(m0fbits & (M0F_FXMSK00 | M0F_FXMSK0F)))
  137.         if(FWrite((char *)(&l2msk0),4)) goto sberr;
  138.     if(!(m0fbits & (M0F_FXMSK10 | M0F_FXMSK1F)))
  139.         if(FWrite((char *)(&l2msk1),4)) goto sberr;
  140.     if(FWrite(conv,data)) goto sberr;
  141.     FreeMem(conv,ONETRKSIZE * (trkn + 2));
  142.     return(FALSE);
  143. sberr:    FreeMem(conv,ONETRKSIZE * (trkn + 2));
  144.     return(TRUE);
  145. }
  146.  
  147. static void UnpackBlock(UWORD bnum,UBYTE *from)
  148. {
  149.     UBYTE *to = lohko[bnum]->music,lcnt,trkn = lohko[bnum]->numtracks;
  150.     ULONG linemsk0 = *((ULONG *)from),linemsk1 = *((ULONG *)from + 1);
  151.     ULONG fxmsk0 = *((ULONG *)from + 2),fxmsk1 = *((ULONG *)from + 3);
  152.     ULONG *lmptr = &linemsk0,*fxptr = &fxmsk0;
  153.     UWORD fromn = 0,lmsk;
  154.     UBYTE *fromst = from + 16,bcnt,*tmpto;
  155.     from += 16;
  156.     for(lcnt = 0; lcnt < 64; lcnt++) {
  157.         if(lcnt == 32) { lmptr = &linemsk1; fxptr = &fxmsk1; }
  158.         if(*lmptr & 0x80000000) {
  159.             lmsk = GetNibbles(fromst,&fromn,(UBYTE)(trkn / 4));
  160.             lmsk <<= (16 - trkn);
  161.             tmpto = to;
  162.             for(bcnt = 0; bcnt < trkn; bcnt++) {
  163.                 if(lmsk & 0x8000) {
  164.                     *tmpto = (UBYTE)GetNibbles(fromst,
  165.                         &fromn,2);
  166.                     *(tmpto+1) = (GetNibble(fromst,
  167.                             &fromn) << 4);
  168.                 }
  169.                 lmsk <<= 1; tmpto += 3;
  170.             }
  171.         }
  172.         if(*fxptr & 0x80000000) {
  173.             lmsk = GetNibbles(fromst,&fromn,(UBYTE)(trkn / 4));
  174.             lmsk <<= (16 - trkn);
  175.             tmpto = to;
  176.             for(bcnt = 0; bcnt < trkn; bcnt++) {
  177.                 if(lmsk & 0x8000) {
  178.                     *(tmpto+1) |= GetNibble(fromst,
  179.                             &fromn);
  180.                     *(tmpto+2) = (UBYTE)GetNibbles(
  181.                         fromst,&fromn,2);
  182.                 }
  183.                 lmsk <<= 1; tmpto += 3;
  184.             }
  185.         }
  186.         to += 3 * trkn;
  187.         *lmptr <<= 1; *fxptr <<= 1;
  188.     }
  189. }
  190.  
  191. BOOL SaveInstruments(BPTR fh)
  192. {
  193.     ULONG imsk = 0;
  194.     UBYTE scnt;
  195.     Ilmoita("Saving samples...");
  196.     for(scnt = 0; scnt < 32; scnt++) {
  197.         imsk <<= 1;
  198.         if(soitin[scnt]) imsk |= 1;
  199.     }
  200.     if(FWrite((char *)(&imsk),4)) return(diskerr(fh,0));
  201.     for(scnt = 0; scnt < 32; scnt++) {
  202.         if(soitin[scnt] && FWrite((char *)soitin[scnt],
  203.             soitin[scnt]->length + sizeof(struct Soitin)))
  204.                 return(diskerr(fh,0));
  205.     }
  206.     return(FALSE);
  207. }
  208.  
  209. BOOL SaveSong(char *name,BOOL sinstr)
  210. {
  211.     UBYTE scnt,oldexists = 0;
  212.     ULONG zmsk0 = 0,zmsk1 = 0,zmsk2 = 0,zmsk3 = 0,zmsk4 = 0;
  213.     extern struct ViewPort *vp;
  214.     if(*name == '\0') return(AskName());
  215.     if(IsHere(name)) {
  216.         Ilmoita("File already exists. Continue?");
  217.         oldexists = 1;
  218.         if(!Continue()) return(TRUE);
  219.     }
  220.     if(sinstr) tamakappale.liput |= LIPPU_SOITTIMETMUKANA;
  221.     else tamakappale.liput &= ~LIPPU_SOITTIMETMUKANA;
  222.     fh = Open2(name,MODE_NEWFILE);
  223.     if(!fh) return(diskerr(fh,0));
  224.     Ilmoita("Saving song...");
  225.     for(scnt = 0; scnt < 8; scnt++)
  226.         tamakappale.rgb[scnt] = GetRGB4(vp->ColorMap,scnt);
  227.     if(FWrite("MED\x03",4)) return(diskerr(fh,0));
  228.     for(scnt = 0; scnt < 32; scnt++) {
  229.         zmsk0 <<= 1; zmsk1 <<= 1; zmsk2 <<= 1; zmsk3 <<= 1;
  230.         zmsk4 <<= 1;
  231.         if(FWrite(tamakappale.soitin[scnt],strlen(tamakappale.
  232.             soitin[scnt]) + 1)) return(diskerr(fh,0));
  233.         if(tamakappale.soittimenvoimakkuus[scnt]) zmsk0 |= 1;
  234.         if(tamakappale.stoisto[scnt]) zmsk1 |= 1;
  235.         if(tamakappale.stoistonpit[scnt]) zmsk2 |= 1;
  236.         if(tamakappale.midikanava[scnt]) zmsk3 |= 1;
  237.         if(tamakappale.midipreset[scnt]) zmsk4 |= 1;
  238.     }
  239.     if(FWrite((char *)(&zmsk0),4)) return(diskerr(fh,0));
  240.     for(scnt = 0; scnt < 32; scnt++) {
  241.         if(!tamakappale.soittimenvoimakkuus[scnt]) continue;
  242.         if(FWrite(&tamakappale.soittimenvoimakkuus[scnt],1)) return(diskerr(fh,0));
  243.     }
  244.     if(FWrite((char *)(&zmsk1),4)) return(diskerr(fh,0));
  245.     for(scnt = 0; scnt < 32; scnt++) {
  246.         if(!tamakappale.stoisto[scnt]) continue;
  247.         if(FWrite((char *)(&tamakappale.stoisto[scnt]),2)) return(diskerr(fh,0));
  248.     }
  249.     if(FWrite((char *)(&zmsk2),4)) return(diskerr(fh,0));
  250.     for(scnt = 0; scnt < 32; scnt++) {
  251.         if(!tamakappale.stoistonpit[scnt]) continue;
  252.         if(FWrite((char *)(&tamakappale.stoistonpit[scnt]),2)) return(diskerr(fh,0));
  253.     }
  254.     if(FWrite((char *)(&lohkoja),2)) return(diskerr(fh,0));
  255.     if(FWrite((char *)(&tamakappale.kappaleen_pituus),2)) return(diskerr(fh,0));
  256.     if(FWrite(tamakappale.soittojarjestys,tamakappale.kappaleen_pituus)) return(diskerr(fh,0));
  257.     if(FWrite((char *)(&tamakappale.tempo),26)) return(diskerr(fh,0));
  258.     if(FWrite((char *)(&zmsk3),4)) return(diskerr(fh,0));
  259.     for(scnt = 0; scnt < 32; scnt++) {
  260.         if(!tamakappale.midikanava[scnt]) continue;
  261.         if(FWrite(&tamakappale.midikanava[scnt],1)) return(diskerr(fh,0));
  262.     }
  263.     if(FWrite((char *)(&zmsk4),4)) return(diskerr(fh,0));
  264.     for(scnt = 0; scnt < 32; scnt++) {
  265.         if(!tamakappale.midipreset[scnt]) continue;
  266.         if(FWrite(&tamakappale.midipreset[scnt],1)) return(diskerr(fh,0));
  267.     }
  268.     for(scnt = 0; scnt < lohkoja; scnt++)
  269.         if(SaveBlock((UWORD)scnt)) return(diskerr(fh,0));
  270.     if(sinstr) SaveInstruments(fh);
  271.     Close(fh);
  272.     if(!oldexists) InsertSavedFile(name);
  273.     if(gadget2[25].GadgetID & 0x1000) {
  274.         Ilmoita("Creating icon...");
  275.         if(WriteIcon(name)) return(FALSE);
  276.     }
  277.     Ilmoita("Song is now saved.");
  278.     return(FALSE);
  279. }
  280.  
  281. BOOL Load200Song(BPTR fh)
  282. {
  283.     ULONG zmsk,*conv = 0;
  284.     UWORD convsz;
  285.     UBYTE scnt,*nameptr,blkcnt,midifound = 0;
  286.     Ilmoita("Loading MED2.00-song...");
  287.     if(FRead(fh,(char *)(&zmsk),4)) return(diskerr(fh,0)); /* MED\x03 */
  288.     for(scnt = 0; scnt < 32; scnt++) {
  289.         nameptr = &tamakappale.soitin[scnt][0];
  290.         for(;;) {
  291.             if(FRead(fh,nameptr,1)) return(diskerr(fh,0));
  292.             if(*nameptr++ == '\0') break;
  293.         }
  294.     }
  295.     if(FRead(fh,(char *)(&zmsk),4)) return(diskerr(fh,0));
  296.     for(scnt = 0; scnt < 32; scnt++) {
  297.         if(zmsk & 0x80000000) {
  298.             if(FRead(fh,&tamakappale.soittimenvoimakkuus[scnt],1)) return(diskerr(fh,0));
  299.         } else tamakappale.soittimenvoimakkuus[scnt] = 0;
  300.         zmsk <<= 1;
  301.     }
  302.     if(FRead(fh,(char *)(&zmsk),4)) return(diskerr(fh,0));
  303.     for(scnt = 0; scnt < 32; scnt++) {
  304.         if(zmsk & 0x80000000) {
  305.             if(FRead(fh,(char *)(&tamakappale.stoisto[scnt]),2)) return(diskerr(fh,0));
  306.         } else tamakappale.stoisto[scnt] = 0;
  307.         zmsk <<= 1;
  308.     }
  309.     if(FRead(fh,(char *)(&zmsk),4)) return(diskerr(fh,0));
  310.     for(scnt = 0; scnt < 32; scnt++) {
  311.         if(zmsk & 0x80000000) {
  312.             if(FRead(fh,(char *)(&tamakappale.stoistonpit[scnt]),2)) return(diskerr(fh,0));
  313.         } else tamakappale.stoistonpit[scnt] = 0;
  314.         zmsk <<= 1;
  315.     }
  316.     if(FRead(fh,(char *)(&tamakappale.lohkoja),2)) return(diskerr(fh,0));
  317.     if(FRead(fh,(char *)(&tamakappale.kappaleen_pituus),2)) return(diskerr(fh,0));
  318.     if(FRead(fh,tamakappale.soittojarjestys,tamakappale.kappaleen_pituus)) return(diskerr(fh,0));
  319.     if(FRead(fh,(char *)(&tamakappale.tempo),26)) return(diskerr(fh,0));
  320.     if(FRead(fh,(char *)(&zmsk),4)) return(diskerr(fh,0));
  321.     for(scnt = 0; scnt < 32; scnt++) {
  322.         if(zmsk & 0x80000000) {
  323.             if(FRead(fh,&tamakappale.midikanava[scnt],1)) return(diskerr(fh,0));
  324.             midifound = 1;
  325.         } else tamakappale.midikanava[scnt] = 0;
  326.         zmsk <<= 1;
  327.     }
  328.     if(FRead(fh,(char *)(&zmsk),4)) return(diskerr(fh,0));
  329.     for(scnt = 0; scnt < 32; scnt++) {
  330.         if(zmsk & 0x80000000) {
  331.             if(FRead(fh,&tamakappale.midipreset[scnt],1)) return(diskerr(fh,0));
  332.         } else tamakappale.midipreset[scnt] = 0;
  333.         zmsk <<= 1;
  334.     }
  335.     lohkoja = 0;
  336.     for(blkcnt = 0; blkcnt < tamakappale.lohkoja; blkcnt++) {
  337.         if(FRead(fh,&scnt,1)) return(diskerr(fh,0));
  338.         if(AllocBlock(blkcnt,scnt)) return(diskerr(fh,"No mem."));
  339.         lohkoja++;
  340.         if(FRead(fh,&scnt,1)) return(diskerr(fh,0));
  341.         if(FRead(fh,(char *)(&convsz),2)) return(diskerr(fh,0));
  342.         if(!(conv = AllocMem(convsz+16,MEMF_PUBLIC|MEMF_CLEAR))) return(diskerr(fh,"Memory..."));
  343.         if(scnt & M0F_LINEMSK00) *conv = 0L;
  344.         else if(scnt & M0F_LINEMSK0F) *conv = 0xffffffff;
  345.         else if(FRead(fh,(UBYTE *)conv,4)) return(diskerr(fh,0));
  346.         if(scnt & M0F_LINEMSK10) *(conv+1) = 0L;
  347.         else if(scnt & M0F_LINEMSK1F) *(conv+1) = 0xffffffff;
  348.         else if(FRead(fh,(UBYTE *)(conv + 1),4)) return(diskerr(fh,0));
  349.         if(scnt & M0F_FXMSK00) *(conv+2) = 0L;
  350.         else if(scnt & M0F_FXMSK0F) *(conv+2) = 0xffffffff;
  351.         else if(FRead(fh,(UBYTE *)(conv + 2),4)) return(diskerr(fh,0));
  352.         if(scnt & M0F_FXMSK10) *(conv+3) = 0L;
  353.         else if(scnt & M0F_FXMSK1F) *(conv+3) = 0xffffffff;
  354.         else if(FRead(fh,(UBYTE *)(conv + 3),4)) return(diskerr(fh,0));
  355.         if(FRead(fh,(UBYTE *)(conv + 4),convsz)) return(diskerr(fh,0));
  356.         UnpackBlock((UWORD)blkcnt,(UBYTE *)conv);
  357.         FreeMem(conv,convsz+16); conv = 0;
  358.     }
  359.     if(midifound) MIDIon();
  360.     return(FALSE);
  361. }
  362.  
  363. static UWORD chip icondata[] = {
  364. 0xffff,0xffff,0xff80,0xc000,0x0,0x180,0xc020,0xbfbe,0x180,0xc031,0x999b,0x180,
  365. 0xc03b,0x9819,0x8180,0xc03f,0x9e19,0x8180,0xc035,0x9819,0x8180,0xc031,0x999b,0x180,
  366. 0xc031,0xbfbe,0x180,0xc3c0,0x0,0x180,0xc660,0x0,0x180,0xc703,0xc7c3,0xb180,
  367. 0xc386,0x6666,0x6180,0xc0e6,0x6666,0x6180,0xc666,0x6663,0xc180,0xc3c3,0xc66c,0x6180,
  368. 0xc000,0x7,0xc180,0xc000,0x0,0x180,0xc000,0x0,0x180,0xffff,0xffff,0xff80,
  369. 0x0,0x0,0x0, /*------ plane # 1: --------*/
  370. 0x0,0x0,0x0,0x3fff,0xffff,0xfe60,0x3020,0xbfbe,0x60,0x3039,0xbfff,0x8060,
  371. 0x303f,0xfe7f,0xc060,0x303f,0xfe1f,0xe060,0x303f,0xff9f,0xe060,0x303d,0xff9f,0x6060,
  372. 0x303d,0xfffe,0xc060,0x33cc,0x6fef,0x8060,0x36f0,0x0,0x60,0x379b,0xc7c3,0xb060,
  373. 0x33c6,0xf7f6,0xec60,0x30e7,0xffff,0xf860,0x367f,0xfffb,0xd860,0x33db,0xdffc,0xf060,
  374. 0x30f0,0xf19f,0xd860,0x3000,0x1,0xf060,0x3000,0x0,0x60,0x0,0x0,0x60,
  375. 0x3fff,0xffff,0xffe0 };
  376.  
  377. BOOL WriteIcon(char *name)
  378. {
  379.     static struct Image dimg = {
  380.         0,0,43,21,2,icondata,0x3,0x0,NULL };
  381.     static struct DiskObject dobj = {
  382.         WB_DISKMAGIC,WB_DISKVERSION,{
  383.             NULL,0,0,43,21,GADGIMAGE|GADGHCOMP,
  384.             GADGIMMEDIATE|RELVERIFY,BOOLGADGET,(APTR)&dimg,
  385.             NULL,NULL,NULL,NULL,0,NULL
  386.         },WBPROJECT,"MEDPlayer",NULL,NO_ICON_POSITION,
  387.         NO_ICON_POSITION,NULL,NULL,NULL
  388.     }; /* vv - This wouldn't work without <proto/icon.h> */
  389.     struct Library *IconBase = OpenLibrary(ICONNAME,0);
  390.     LONG status;
  391.     if(!IconBase) {
  392.         Ilmoita("No icon.library: no icon.");
  393.         return(TRUE);
  394.     }
  395.     status = PutDiskObject(name,&dobj);
  396.     CloseLibrary(IconBase);
  397.     if(!status) {
  398.         Ilmoita("Failed to create icon.");
  399.         return(TRUE);
  400.     }
  401.     return(FALSE);
  402. }
  403.  
  404. static UWORD chip contdata[] = {
  405. 0x7fff,0xffff,0xffff,0xffff,0x3fff,0xffff,0xffff,0xffff,0x3fff,0xffff,0xffff,0xffff,
  406. 0x3fff,0xffff,0xffff,0xffff,0x2000,0x0,0x80,0x7,0x3fff,0xffff,0xfeff,0xfff7,
  407. 0x3ccd,0xa2b5,0xa2f2,0x3337,0x3bb4,0xb695,0xaeef,0x6d57,0x3bb5,0x36a5,0xa6f3,0x6d37,
  408. 0x3bb5,0xb6b5,0xaefd,0x6d77,0x3ccd,0xb6b6,0x62e3,0x7377,0x3fff,0xffff,0xfeff,0xfff7,
  409. 0x3fff,0xffff,0xfeff,0xfff7,0x3fff,0xffff,0xffff,0xffff,0x3fff,0xffff,0xffff,0xffff,
  410. 0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x1, /*------ plane # 1: --------*/
  411. 0x8000,0x0,0x0,0x0,0xc000,0x0,0x0,0x0,0xffff,0xffff,0xffff,0xfffc,
  412. 0xffff,0xffff,0xffff,0xfffc,0xffff,0xffff,0xffff,0xfffc,0xefff,0xffff,0xffbf,0xfffc,
  413. 0xeccd,0xa2b5,0xa3b2,0x333c,0xebb4,0xb695,0xafaf,0x6d5c,0xebb5,0x36a5,0xa7b3,0x6d3c,
  414. 0xebb5,0xb6b5,0xafbd,0x6d7c,0xeccd,0xb6b6,0x63a3,0x737c,0xefff,0xffff,0xffbf,0xfffc,
  415. 0xe000,0x0,0x180,0xc,0xffff,0xffff,0xffff,0xfffc,0xffff,0xffff,0xffff,0xfffc,
  416. 0xffff,0xffff,0xffff,0xfffc,0xffff,0xffff,0xffff,0xfffe };
  417.  
  418. BOOL Continue()
  419. {
  420.     static struct Image contimg = { 0,0,64,17,2,contdata,0x3,0x0,NULL };
  421.     static struct Gadget cgadg[] = {
  422.     { &cgadg[1],4,5,35,7,GADGHCOMP,RELVERIFY,BOOLGADGET,NULL,NULL,
  423.       NULL,NULL,NULL,0,NULL },
  424.     { NULL,42,5,18,7,GADGHCOMP,RELVERIFY,BOOLGADGET,NULL,NULL,
  425.       NULL,NULL,NULL,0,NULL } };
  426.     static struct NewWindow cneww = { 160,20,64,17,0,0,GADGETUP|RAWKEY,
  427.         SMART_REFRESH|BORDERLESS|ACTIVATE|RMBTRAP,&cgadg[0],
  428.         NULL,NULL,NULL,NULL,0,0,0,0,CUSTOMSCREEN };
  429.     struct Window *cwin;
  430.     struct IntuiMessage *msg;
  431.     UWORD res = 0;
  432.     cneww.Screen = screen;
  433.     if(!(cwin = OpenWindow(&cneww))) return(FALSE);
  434.     DrawImage(cwin->RPort,&contimg,0,0);
  435.     for(;;) {
  436.         WaitPort(cwin->UserPort);
  437.         msg = (struct IntuiMessage *)GetMsg(cwin->UserPort);
  438.         if(msg->Class == GADGETUP) {
  439.             if(msg->IAddress == (APTR)&cgadg[0]) res = 1;
  440.             else res = 2;
  441.         } else if(msg->Class == RAWKEY) {
  442.             if(msg->Code == 0x33) res = 1;
  443.             else if(msg->Code == 0x21) res = 2;
  444.         }
  445.         ReplyMsg((struct Message *)msg);
  446.         if(res) break;
  447.     }
  448.     CloseWindow(cwin);
  449.     if(res == 1) return(TRUE);
  450.     return(FALSE);
  451. }
  452.  
  453. BOOL AskName()
  454. {
  455.     Ilmoita("Type in the name:");
  456.     OsionValinta(&gadget1[0]);
  457.     ActivateGadget(&gadget2[9],window,NULL);
  458.     return(TRUE);
  459. }
  460.  
  461. BOOL LoadAttachedInstrs(BPTR fh)
  462. {
  463.     ULONG imsk;
  464.     struct Soitin loaded;
  465.     if(FRead(fh,(char *)(&imsk),4)) return(diskerr(0,0));
  466.     soittimennum = 0;
  467.     while(soittimennum < 31) {
  468.         imsk <<= 1;    /* There's no instrument #0 */
  469.         SeurSoitin();
  470.         if(imsk & 0x80000000) {
  471.             if(FRead(fh,(char *)(&loaded),sizeof(struct Soitin)))
  472.                 return(diskerr(0,0));
  473.             if(NewInstrument(loaded.length,soittimennum))
  474.                 return(diskerr(0,"Help...no memory!!!"));
  475.             soitin[soittimennum]->type = loaded.type;
  476.             if(FRead(fh,((char *)soitin[soittimennum]) +
  477.                 sizeof(struct Soitin),loaded.length))
  478.                 return(diskerr(0,0));
  479.         }
  480.     }
  481.     return(FALSE);
  482. }
  483.  
  484. BOOL SaveRawSample(char *name)
  485. {
  486.     UBYTE oldexists = 0;
  487.     if(!soitin[soittimennum]) {
  488.         Ilmoita("There's no sample to save!!");
  489.         return(TRUE);
  490.     }
  491.     if(*name == '\0') {
  492.         UWORD pos;
  493.         if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[9]);
  494.         strcpy(kappaleennimi,tamakappale.soitin[soittimennum]);
  495.         if(nykyinenosio == 2) {
  496.             AddGadget(window,&gadget2[9],pos);
  497.             RefreshGList(&gadget2[9],window,NULL,1);
  498.         }
  499.         return(TRUE);
  500.     }
  501.     if(IsHere(name)) {
  502.         Ilmoita("File already exists. Continue?");
  503.         oldexists = 1;
  504.         if(!Continue()) return(TRUE);
  505.     }
  506.     if(!(fh = Open2(name,MODE_NEWFILE))) return(diskerr(0,0));
  507.     if(FWrite(((char *)(soitin[soittimennum])) + sizeof(struct Soitin),
  508.         soitin[soittimennum]->length & 0xfffffffe)) return(diskerr(fh,0));
  509.     Close(fh);
  510.     if(!oldexists) InsertSavedFile(name);
  511.     Ilmoita("Sample is now saved.");
  512.     return(FALSE);
  513. }
  514.